ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಸಿಂಕ್ ಕಾಂಟೆಕ್ಸ್ಟ್: ರಿಕ್ವೆಸ್ಟ್-ಸ್ಕೋಪ್ಡ್ ವೇರಿಯಬಲ್ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್‌ನಲ್ಲಿ ಪ್ರಾವೀಣ್ಯತೆ

ಅಸಿಂಕ್ರೋನಸ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಆಧುನಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಭಿವೃದ್ಧಿಯ ಮೂಲಾಧಾರವಾಗಿದೆ, ವಿಶೇಷವಾಗಿ Node.js ನಂತಹ ಪರಿಸರದಲ್ಲಿ. ಆದಾಗ್ಯೂ, ಅಸಿಂಕ್ರೋನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳಾದ್ಯಂತ ಕಾಂಟೆಕ್ಸ್ಟ್ ಮತ್ತು ರಿಕ್ವೆಸ್ಟ್-ಸ್ಕೋಪ್ಡ್ ವೇರಿಯಬಲ್ಸ್ ಅನ್ನು ನಿರ್ವಹಿಸುವುದು ಸವಾಲಿನ ಸಂಗತಿಯಾಗಿದೆ. ಸಾಂಪ್ರದಾಯಿಕ ವಿಧಾನಗಳು ಸಂಕೀರ್ಣ ಕೋಡ್ ಮತ್ತು ಸಂಭಾವ್ಯ ಡೇಟಾ ಭ್ರಷ್ಟಾಚಾರಕ್ಕೆ ಕಾರಣವಾಗುತ್ತವೆ. ಈ ಲೇಖನವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ಅಸಿಂಕ್ರೋನಸ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ಸಾಮರ್ಥ್ಯಗಳನ್ನು, ನಿರ್ದಿಷ್ಟವಾಗಿ AsyncLocalStorage ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸಿ, ಮತ್ತು ದೃಢವಾದ ಮತ್ತು ಸ್ಕೇಲೆಬಲ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಇದು ಹೇಗೆ ರಿಕ್ವೆಸ್ಟ್-ಸ್ಕೋಪ್ಡ್ ವೇರಿಯಬಲ್ ನಿರ್ವಹಣೆಯನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತದೆ.

ಅಸಿಂಕ್ರೋನಸ್ ಕಾಂಟೆಕ್ಸ್ಟ್‌ನ ಸವಾಲುಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ಸಿಂಕ್ರೋನಸ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿ, ಫಂಕ್ಷನ್‌ನ ಸ್ಕೋಪ್‌ನೊಳಗೆ ವೇರಿಯಬಲ್ಸ್ ಅನ್ನು ನಿರ್ವಹಿಸುವುದು ಸರಳವಾಗಿದೆ. ಪ್ರತಿಯೊಂದು ಫಂಕ್ಷನ್‌ಗೂ ತನ್ನದೇ ಆದ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ಇರುತ್ತದೆ ಮತ್ತು ಆ ಕಾಂಟೆಕ್ಸ್ಟ್‌ನೊಳಗೆ ಘೋಷಿಸಲಾದ ವೇರಿಯಬಲ್ಸ್ ಪ್ರತ್ಯೇಕವಾಗಿರುತ್ತವೆ. ಆದಾಗ್ಯೂ, ಅಸಿಂಕ್ರೋನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳು ರೇಖೀಯವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸದ ಕಾರಣ ಸಂಕೀರ್ಣತೆಗಳನ್ನು ಪರಿಚಯಿಸುತ್ತವೆ. ಕಾಲ್‌ಬ್ಯಾಕ್‌ಗಳು, ಪ್ರಾಮಿಸ್‌ಗಳು, ಮತ್ತು async/await ಹೊಸ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಕಾಂಟೆಕ್ಸ್ಟ್‌ಗಳನ್ನು ಪರಿಚಯಿಸುತ್ತವೆ, ಇದು ನಿರ್ದಿಷ್ಟ ವಿನಂತಿ ಅಥವಾ ಕಾರ್ಯಾಚರಣೆಗೆ ಸಂಬಂಧಿಸಿದ ವೇರಿಯಬಲ್ಸ್ ಅನ್ನು ನಿರ್ವಹಿಸಲು ಮತ್ತು ಪ್ರವೇಶಿಸಲು ಕಷ್ಟವಾಗಿಸುತ್ತದೆ.

ರಿಕ್ವೆಸ್ಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ನ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಉದ್ದಕ್ಕೂ ನೀವು ಒಂದು ವಿಶಿಷ್ಟ ರಿಕ್ವೆಸ್ಟ್ ID ಅನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಬೇಕಾದ ಸನ್ನಿವೇಶವನ್ನು ಪರಿಗಣಿಸಿ. ಸರಿಯಾದ ಯಾಂತ್ರಿಕ ವ್ಯವಸ್ಥೆಯಿಲ್ಲದೆ, ರಿಕ್ವೆಸ್ಟ್ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ತೊಡಗಿರುವ ಪ್ರತಿಯೊಂದು ಫಂಕ್ಷನ್‌ಗೆ ರಿಕ್ವೆಸ್ಟ್ ID ಅನ್ನು ಆರ್ಗ್ಯುಮೆಂಟ್ ಆಗಿ ಪಾಸ್ ಮಾಡುವ ವಿಧಾನವನ್ನು ನೀವು ಆಶ್ರಯಿಸಬಹುದು. ಈ ವಿಧಾನವು ತೊಡಕಿನದು, ದೋಷಪೂರಿತವಾದುದು, ಮತ್ತು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಬಿಗಿಯಾಗಿ ಜೋಡಿಸುತ್ತದೆ.

ಕಾಂಟೆಕ್ಸ್ಟ್ ಪ್ರೊಪಗೇಷನ್‌ನ ಸಮಸ್ಯೆ

• ಕೋಡ್ ಕ್ಲಟರ್: ಬಹು ಫಂಕ್ಷನ್ ಕರೆಗಳ ಮೂಲಕ ಕಾಂಟೆಕ್ಸ್ಟ್ ವೇರಿಯಬಲ್ಸ್ ಅನ್ನು ಪಾಸ್ ಮಾಡುವುದರಿಂದ ಕೋಡ್ ಸಂಕೀರ್ಣತೆಯನ್ನು ಗಣನೀಯವಾಗಿ ಹೆಚ್ಚಿಸುತ್ತದೆ ಮತ್ತು ಓದುವಿಕೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.
• ಬಿಗಿಯಾದ ಜೋಡಣೆ: ಫಂಕ್ಷನ್‌ಗಳು ನಿರ್ದಿಷ್ಟ ಕಾಂಟೆಕ್ಸ್ಟ್ ವೇರಿಯಬಲ್ಸ್ ಮೇಲೆ ಅವಲಂಬಿತವಾಗುತ್ತವೆ, ಅವುಗಳನ್ನು ಕಡಿಮೆ ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಮತ್ತು ಪರೀಕ್ಷಿಸಲು ಕಷ್ಟವಾಗಿಸುತ್ತವೆ.
• ದೋಷಪೂರಿತ: ಕಾಂಟೆಕ್ಸ್ಟ್ ವೇರಿಯಬಲ್ ಅನ್ನು ಪಾಸ್ ಮಾಡಲು ಮರೆಯುವುದು ಅಥವಾ ತಪ್ಪು ಮೌಲ್ಯವನ್ನು ಪಾಸ್ ಮಾಡುವುದರಿಂದ ಅನಿರೀಕ್ಷಿತ ನಡವಳಿಕೆ ಮತ್ತು ಡೀಬಗ್ ಮಾಡಲು ಕಷ್ಟಕರವಾದ ಸಮಸ್ಯೆಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು.
• ನಿರ್ವಹಣಾ ಹೊರೆ: ಕಾಂಟೆಕ್ಸ್ಟ್ ವೇರಿಯಬಲ್ಸ್‌ನಲ್ಲಿನ ಬದಲಾವಣೆಗಳಿಗೆ ಕೋಡ್‌ಬೇಸ್‌ನ ಹಲವು ಭಾಗಗಳಲ್ಲಿ ಮಾರ್ಪಾಡುಗಳ ಅಗತ್ಯವಿರುತ್ತದೆ.

ಈ ಸವಾಲುಗಳು ಅಸಿಂಕ್ರೋನಸ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪರಿಸರದಲ್ಲಿ ರಿಕ್ವೆಸ್ಟ್-ಸ್ಕೋಪ್ಡ್ ವೇರಿಯಬಲ್ಸ್ ಅನ್ನು ನಿರ್ವಹಿಸಲು ಹೆಚ್ಚು ಸುಂದರವಾದ ಮತ್ತು ದೃಢವಾದ ಪರಿಹಾರದ ಅಗತ್ಯವನ್ನು ಎತ್ತಿ ತೋರಿಸುತ್ತವೆ.

AsyncLocalStorage ಅನ್ನು ಪರಿಚಯಿಸುವುದು: ಅಸಿಂಕ್ ಕಾಂಟೆಕ್ಸ್ಟ್‌ಗಾಗಿ ಒಂದು ಪರಿಹಾರ

Node.js v14.5.0 ನಲ್ಲಿ ಪರಿಚಯಿಸಲಾದ AsyncLocalStorage, ಅಸಿಂಕ್ರೋನಸ್ ಕಾರ್ಯಾಚರಣೆಯ ಜೀವಿತಾವಧಿಯುದ್ದಕ್ಕೂ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ಒಂದು ಯಾಂತ್ರಿಕ ವ್ಯವಸ್ಥೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ. ಇದು ಮೂಲಭೂತವಾಗಿ ಅಸಿಂಕ್ರೋನಸ್ ಗಡಿಗಳಾದ್ಯಂತ ನಿರಂತರವಾಗಿರುವ ಒಂದು ಕಾಂಟೆಕ್ಸ್ಟ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ, ನಿರ್ದಿಷ್ಟ ರಿಕ್ವೆಸ್ಟ್ ಅಥವಾ ಕಾರ್ಯಾಚರಣೆಗೆ ಸಂಬಂಧಿಸಿದ ವೇರಿಯಬಲ್ಸ್ ಅನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಪಾಸ್ ಮಾಡದೆಯೇ ಪ್ರವೇಶಿಸಲು ಮತ್ತು ಮಾರ್ಪಡಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

AsyncLocalStorage ಪ್ರತಿ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ಆಧಾರದ ಮೇಲೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಪ್ರತಿಯೊಂದು ಅಸಿಂಕ್ರೋನಸ್ ಕಾರ್ಯಾಚರಣೆ (ಉದಾ., ರಿಕ್ವೆಸ್ಟ್ ಹ್ಯಾಂಡ್ಲರ್) ತನ್ನದೇ ಆದ ಪ್ರತ್ಯೇಕ ಸಂಗ್ರಹಣೆಯನ್ನು ಪಡೆಯುತ್ತದೆ. ಇದು ಒಂದು ರಿಕ್ವೆಸ್ಟ್‌ನೊಂದಿಗೆ ಸಂಬಂಧಿಸಿದ ಡೇಟಾ ಇನ್ನೊಂದಕ್ಕೆ ಆಕಸ್ಮಿಕವಾಗಿ ಸೋರಿಕೆಯಾಗದಂತೆ ಖಚಿತಪಡಿಸುತ್ತದೆ, ಡೇಟಾ ಸಮಗ್ರತೆ ಮತ್ತು ಪ್ರತ್ಯೇಕತೆಯನ್ನು ಕಾಪಾಡುತ್ತದೆ.

AsyncLocalStorage ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ

AsyncLocalStorage ಕ್ಲಾಸ್ ಈ ಕೆಳಗಿನ ಪ್ರಮುಖ ಮೆಥಡ್‌ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ:

• getStore(): ಪ್ರಸ್ತುತ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಕಾಂಟೆಕ್ಸ್ಟ್‌ನೊಂದಿಗೆ ಸಂಬಂಧಿಸಿದ ಪ್ರಸ್ತುತ ಸ್ಟೋರ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಯಾವುದೇ ಸ್ಟೋರ್ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದಿದ್ದರೆ, ಅದು undefined ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
• run(store, callback, ...args): ಒದಗಿಸಿದ callback ಅನ್ನು ಹೊಸ ಅಸಿಂಕ್ರೋನಸ್ ಕಾಂಟೆಕ್ಸ್ಟ್‌ನೊಳಗೆ ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ. store ಆರ್ಗ್ಯುಮೆಂಟ್ ಕಾಂಟೆಕ್ಸ್ಟ್‌ನ ಸಂಗ್ರಹಣೆಯನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ. ಕಾಲ್‌ಬ್ಯಾಕ್‌ನಿಂದ ಪ್ರಚೋದಿಸಲ್ಪಟ್ಟ ಎಲ್ಲಾ ಅಸಿಂಕ್ರೋನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳು ಈ ಸ್ಟೋರ್‌ಗೆ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿರುತ್ತವೆ.
• enterWith(store): ಒದಗಿಸಿದ store ನ ಕಾಂಟೆಕ್ಸ್ಟ್ ಅನ್ನು ಪ್ರವೇಶಿಸುತ್ತದೆ. ನೀವು ನಿರ್ದಿಷ್ಟ ಕೋಡ್ ಬ್ಲಾಕ್‌ಗಾಗಿ ಕಾಂಟೆಕ್ಸ್ಟ್ ಅನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಸೆಟ್ ಮಾಡಬೇಕಾದಾಗ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ.
• disable(): AsyncLocalStorage ಇನ್‌ಸ್ಟನ್ಸ್ ಅನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ. ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಿದ ನಂತರ ಸ್ಟೋರ್ ಅನ್ನು ಪ್ರವೇಶಿಸಿದರೆ ದೋಷ ಉಂಟಾಗುತ್ತದೆ.

ಸ್ಟೋರ್ ಸ್ವತಃ ಒಂದು ಸರಳ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಆಬ್ಜೆಕ್ಟ್ (ಅಥವಾ ನೀವು ಆಯ್ಕೆಮಾಡುವ ಯಾವುದೇ ಡೇಟಾ ಟೈಪ್) ಆಗಿದ್ದು, ನೀವು ನಿರ್ವಹಿಸಲು ಬಯಸುವ ಕಾಂಟೆಕ್ಸ್ಟ್ ವೇರಿಯಬಲ್ಸ್ ಅನ್ನು ಹೊಂದಿರುತ್ತದೆ. ನೀವು ರಿಕ್ವೆಸ್ಟ್ IDಗಳು, ಬಳಕೆದಾರರ ಮಾಹಿತಿ, ಅಥವಾ ಪ್ರಸ್ತುತ ಕಾರ್ಯಾಚರಣೆಗೆ ಸಂಬಂಧಿಸಿದ ಯಾವುದೇ ಇತರ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಬಹುದು.

AsyncLocalStorage ನ ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು

AsyncLocalStorage ಬಳಕೆಯನ್ನು ಹಲವಾರು ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ವಿವರಿಸೋಣ.

ಉದಾಹರಣೆ 1: ವೆಬ್ ಸರ್ವರ್‌ನಲ್ಲಿ ರಿಕ್ವೆಸ್ಟ್ ID ಟ್ರ್ಯಾಕಿಂಗ್

Express.js ಬಳಸುವ Node.js ವೆಬ್ ಸರ್ವರ್ ಅನ್ನು ಪರಿಗಣಿಸಿ. ನಾವು ಪ್ರತಿ ಒಳಬರುವ ರಿಕ್ವೆಸ್ಟ್‌ಗಾಗಿ ಒಂದು ವಿಶಿಷ್ಟ ರಿಕ್ವೆಸ್ಟ್ ID ಅನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ರಚಿಸಲು ಮತ್ತು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಬಯಸುತ್ತೇವೆ. ಈ ID ಅನ್ನು ಲಾಗಿಂಗ್, ಟ್ರೇಸಿಂಗ್, ಮತ್ತು ಡೀಬಗ್ಗಿಂಗ್‌ಗಾಗಿ ಬಳಸಬಹುದು.

const express = require('express');
const { AsyncLocalStorage } = require('async_hooks');
const { v4: uuidv4 } = require('uuid');

const app = express();
const asyncLocalStorage = new AsyncLocalStorage();

app.use((req, res, next) => {
  const requestId = uuidv4();
  asyncLocalStorage.run(new Map(), () => {
    asyncLocalStorage.getStore().set('requestId', requestId);
    console.log(`Request received with ID: ${requestId}`);
    next();
  });
});

app.get('/', (req, res) => {
  const requestId = asyncLocalStorage.getStore().get('requestId');
  console.log(`Handling request with ID: ${requestId}`);
  res.send(`Hello, Request ID: ${requestId}`);
});

app.listen(3000, () => {
  console.log('Server listening on port 3000');
});

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ:

• ನಾವು AsyncLocalStorage ಇನ್‌ಸ್ಟನ್ಸ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ.
• ಪ್ರತಿ ಒಳಬರುವ ರಿಕ್ವೆಸ್ಟ್ ಅನ್ನು ತಡೆಯಲು ನಾವು Express ಮಿಡಲ್‌ವೇರ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ.
• ಮಿಡಲ್‌ವೇರ್ ಒಳಗೆ, ನಾವು uuidv4() ಬಳಸಿ ಒಂದು ವಿಶಿಷ್ಟ ರಿಕ್ವೆಸ್ಟ್ ID ಅನ್ನು ರಚಿಸುತ್ತೇವೆ.
• ನಾವು asyncLocalStorage.run() ಅನ್ನು ಕರೆದು ಹೊಸ ಅಸಿಂಕ್ರೋನಸ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ. ನಮ್ಮ ಕಾಂಟೆಕ್ಸ್ಟ್ ವೇರಿಯಬಲ್ಸ್ ಅನ್ನು ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವ Map ನೊಂದಿಗೆ ಸ್ಟೋರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ.
• run() ಕಾಲ್‌ಬ್ಯಾಕ್ ಒಳಗೆ, ನಾವು asyncLocalStorage.getStore().set('requestId', requestId) ಬಳಸಿ ಸ್ಟೋರ್‌ನಲ್ಲಿ requestId ಅನ್ನು ಸೆಟ್ ಮಾಡುತ್ತೇವೆ.
• ನಂತರ ನಾವು ಮುಂದಿನ ಮಿಡಲ್‌ವೇರ್ ಅಥವಾ ರೂಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗೆ ನಿಯಂತ್ರಣವನ್ನು ರವಾನಿಸಲು next() ಅನ್ನು ಕರೆಯುತ್ತೇವೆ.
• ರೂಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ನಲ್ಲಿ (app.get('/')), ನಾವು asyncLocalStorage.getStore().get('requestId') ಬಳಸಿ ಸ್ಟೋರ್‌ನಿಂದ requestId ಅನ್ನು ಹಿಂಪಡೆಯುತ್ತೇವೆ.

ಈಗ, ರಿಕ್ವೆಸ್ಟ್ ಹ್ಯಾಂಡ್ಲರ್ ಒಳಗೆ ಎಷ್ಟು ಅಸಿಂಕ್ರೋನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳು ಪ್ರಚೋದಿಸಲ್ಪಟ್ಟರೂ, ನೀವು ಯಾವಾಗಲೂ asyncLocalStorage.getStore().get('requestId') ಬಳಸಿ ರಿಕ್ವೆಸ್ಟ್ ID ಅನ್ನು ಪ್ರವೇಶಿಸಬಹುದು.

ಉದಾಹರಣೆ 2: ಬಳಕೆದಾರರ ದೃಢೀಕರಣ ಮತ್ತು ಅಧಿಕಾರ

ಇನ್ನೊಂದು ಸಾಮಾನ್ಯ ಬಳಕೆಯೆಂದರೆ ಬಳಕೆದಾರರ ದೃಢೀಕರಣ ಮತ್ತು ಅಧಿಕಾರ ಮಾಹಿತಿಯನ್ನು ನಿರ್ವಹಿಸುವುದು. ಬಳಕೆದಾರರನ್ನು ದೃಢೀಕರಿಸಿ ಅವರ ಬಳಕೆದಾರ ID ಯನ್ನು ಹಿಂಪಡೆಯುವ ಮಿಡಲ್‌ವೇರ್ ನಿಮ್ಮಲ್ಲಿದೆ ಎಂದು ಭಾವಿಸೋಣ. ನೀವು ಬಳಕೆದಾರ ID ಅನ್ನು AsyncLocalStorage ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಬಹುದು, ಇದರಿಂದ ಅದು ನಂತರದ ಮಿಡಲ್‌ವೇರ್ ಮತ್ತು ರೂಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳಿಗೆ ಲಭ್ಯವಾಗುತ್ತದೆ.

const express = require('express');
const { AsyncLocalStorage } = require('async_hooks');

const app = express();
const asyncLocalStorage = new AsyncLocalStorage();

// ಬಳಕೆದಾರರ ದೃಢೀಕರಣ ಮಿಡಲ್‌ವೇರ್ (ಉದಾಹರಣೆ)
const authenticateUser = (req, res, next) => {
  // ಬಳಕೆದಾರರ ದೃಢೀಕರಣವನ್ನು ಅನುಕರಿಸಿ (ನಿಮ್ಮ ನಿಜವಾದ ಲಾಜಿಕ್‌ನೊಂದಿಗೆ ಬದಲಾಯಿಸಿ)
  const userId = req.headers['x-user-id'] || 'guest'; // ಹೆಡರ್‌ನಿಂದ ಬಳಕೆದಾರ ID ಪಡೆಯಿರಿ

  asyncLocalStorage.run(new Map(), () => {
    asyncLocalStorage.getStore().set('userId', userId);
    console.log(`User authenticated with ID: ${userId}`);
    next();
  });
};

app.use(authenticateUser);

app.get('/profile', (req, res) => {
  const userId = asyncLocalStorage.getStore().get('userId');
  console.log(`Accessing profile for user ID: ${userId}`);
  res.send(`Profile for User ID: ${userId}`);
});

app.listen(3000, () => {
  console.log('Server listening on port 3000');
});

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, authenticateUser ಮಿಡಲ್‌ವೇರ್ ಬಳಕೆದಾರ ID ಅನ್ನು ಹಿಂಪಡೆಯುತ್ತದೆ (ಇಲ್ಲಿ ಹೆಡರ್ ಅನ್ನು ಓದುವ ಮೂಲಕ ಅನುಕರಿಸಲಾಗಿದೆ) ಮತ್ತು ಅದನ್ನು AsyncLocalStorage ನಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ. /profile ರೂಟ್ ಹ್ಯಾಂಡ್ಲರ್ ನಂತರ ಬಳಕೆದಾರ ID ಅನ್ನು ಸ್ಪಷ್ಟ ಪ್ಯಾರಾಮೀಟರ್ ಆಗಿ ಸ್ವೀಕರಿಸದೆಯೇ ಪ್ರವೇಶಿಸಬಹುದು.

ಉದಾಹರಣೆ 3: ಡೇಟಾಬೇಸ್ ಟ್ರಾನ್ಸಾಕ್ಷನ್ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್

ಡೇಟಾಬೇಸ್ ಟ್ರಾನ್ಸಾಕ್ಷನ್‌ಗಳನ್ನು ಒಳಗೊಂಡ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ, AsyncLocalStorage ಅನ್ನು ಟ್ರಾನ್ಸಾಕ್ಷನ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ಅನ್ನು ನಿರ್ವಹಿಸಲು ಬಳಸಬಹುದು. ನೀವು ಡೇಟಾಬೇಸ್ ಸಂಪರ್ಕ ಅಥವಾ ಟ್ರಾನ್ಸಾಕ್ಷನ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು AsyncLocalStorage ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಬಹುದು, ಇದರಿಂದ ನಿರ್ದಿಷ್ಟ ರಿಕ್ವೆಸ್ಟ್‌ನೊಳಗಿನ ಎಲ್ಲಾ ಡೇಟಾಬೇಸ್ ಕಾರ್ಯಾಚರಣೆಗಳು ಒಂದೇ ಟ್ರಾನ್ಸಾಕ್ಷನ್ ಅನ್ನು ಬಳಸುತ್ತವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬಹುದು.

const express = require('express');
const { AsyncLocalStorage } = require('async_hooks');

const app = express();
const asyncLocalStorage = new AsyncLocalStorage();

// ಡೇಟಾಬೇಸ್ ಸಂಪರ್ಕವನ್ನು ಅನುಕರಿಸಿ
const db = {
  query: (sql, callback) => {
    const transactionId = asyncLocalStorage.getStore()?.get('transactionId') || 'No Transaction';
    console.log(`Executing SQL: ${sql} in Transaction: ${transactionId}`);
    // ಡೇಟಾಬೇಸ್ ಕ್ವೆರಿ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಅನ್ನು ಅನುಕರಿಸಿ
    setTimeout(() => {
      callback(null, { success: true });
    }, 50);
  },
};

// ಟ್ರಾನ್ಸಾಕ್ಷನ್ ಪ್ರಾರಂಭಿಸಲು ಮಿಡಲ್‌ವೇರ್
const startTransaction = (req, res, next) => {
  const transactionId = Math.random().toString(36).substring(2, 15); // ಯಾದೃಚ್ಛಿಕ ಟ್ರಾನ್ಸಾಕ್ಷನ್ ID ಅನ್ನು ರಚಿಸಿ

  asyncLocalStorage.run(new Map(), () => {
    asyncLocalStorage.getStore().set('transactionId', transactionId);
    console.log(`Starting transaction: ${transactionId}`);
    next();
  });
};

app.use(startTransaction);

app.get('/data', (req, res) => {
  db.query('SELECT * FROM data', (err, result) => {
    if (err) {
      return res.status(500).send('Error querying data');
    }
    res.send('Data retrieved successfully');
  });
});

app.listen(3000, () => {
  console.log('Server listening on port 3000');
});

ಈ ಸರಳೀಕೃತ ಉದಾಹರಣೆಯಲ್ಲಿ:

• startTransaction ಮಿಡಲ್‌ವೇರ್ ಒಂದು ಟ್ರಾನ್ಸಾಕ್ಷನ್ ID ಅನ್ನು ರಚಿಸಿ ಅದನ್ನು AsyncLocalStorage ನಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ.
• ಅನುಕರಿಸಿದ db.query ಫಂಕ್ಷನ್ ಸ್ಟೋರ್‌ನಿಂದ ಟ್ರಾನ್ಸಾಕ್ಷನ್ ID ಅನ್ನು ಹಿಂಪಡೆಯುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಲಾಗ್ ಮಾಡುತ್ತದೆ, ಅಸಿಂಕ್ರೋನಸ್ ಡೇಟಾಬೇಸ್ ಕಾರ್ಯಾಚರಣೆಯೊಳಗೆ ಟ್ರಾನ್ಸಾಕ್ಷನ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ಲಭ್ಯವಿದೆ ಎಂದು ಪ್ರದರ್ಶಿಸುತ್ತದೆ.

ಸುಧಾರಿತ ಬಳಕೆ ಮತ್ತು ಪರಿಗಣನೆಗಳು

ಮಿಡಲ್‌ವೇರ್ ಮತ್ತು ಕಾಂಟೆಕ್ಸ್ಟ್ ಪ್ರೊಪಗೇಷನ್

AsyncLocalStorage ವಿಶೇಷವಾಗಿ ಮಿಡಲ್‌ವೇರ್ ಚೈನ್‌ಗಳಲ್ಲಿ ಉಪಯುಕ್ತವಾಗಿದೆ. ಪ್ರತಿಯೊಂದು ಮಿಡಲ್‌ವೇರ್ ಹಂಚಿಕೆಯ ಕಾಂಟೆಕ್ಸ್ಟ್ ಅನ್ನು ಪ್ರವೇಶಿಸಬಹುದು ಮತ್ತು ಮಾರ್ಪಡಿಸಬಹುದು, ಇದರಿಂದ ನೀವು ಸಂಕೀರ್ಣ ಪ್ರೊಸೆಸಿಂಗ್ ಪೈಪ್‌ಲೈನ್‌ಗಳನ್ನು ಸುಲಭವಾಗಿ ನಿರ್ಮಿಸಬಹುದು.

ನಿಮ್ಮ ಮಿಡಲ್‌ವೇರ್ ಫಂಕ್ಷನ್‌ಗಳು ಕಾಂಟೆಕ್ಸ್ಟ್ ಅನ್ನು ಸರಿಯಾಗಿ ಪ್ರೊಪಗೇಟ್ ಮಾಡಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ಅಸಿಂಕ್ರೋನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಸುತ್ತುವರಿಯಲು ಮತ್ತು ಕಾಂಟೆಕ್ಸ್ಟ್ ಫ್ಲೋವನ್ನು ನಿರ್ವಹಿಸಲು asyncLocalStorage.run() ಅಥವಾ asyncLocalStorage.enterWith() ಬಳಸಿ.

ದೋಷ ನಿರ್ವಹಣೆ ಮತ್ತು ಕ್ಲೀನಪ್

AsyncLocalStorage ಬಳಸುವಾಗ ಸರಿಯಾದ ದೋಷ ನಿರ್ವಹಣೆ ಅತ್ಯಗತ್ಯ. ನೀವು ವಿನಾಯಿತಿಗಳನ್ನು ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸುತ್ತೀರಿ ಮತ್ತು ಕಾಂಟೆಕ್ಸ್ಟ್‌ನೊಂದಿಗೆ ಸಂಬಂಧಿಸಿದ ಯಾವುದೇ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸುತ್ತೀರಿ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ದೋಷ ಸಂಭವಿಸಿದರೂ ಸಂಪನ್ಮೂಲಗಳು ಬಿಡುಗಡೆಯಾಗುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು try...finally ಬ್ಲಾಕ್‌ಗಳನ್ನು ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಿ.

ಕಾರ್ಯಕ್ಷಮತೆಯ ಪರಿಗಣನೆಗಳು

AsyncLocalStorage ಕಾಂಟೆಕ್ಸ್ಟ್ ಅನ್ನು ನಿರ್ವಹಿಸಲು ಅನುಕೂಲಕರ ಮಾರ್ಗವನ್ನು ಒದಗಿಸಿದರೂ, ಅದರ ಕಾರ್ಯಕ್ಷಮತೆಯ ಪರಿಣಾಮಗಳ ಬಗ್ಗೆ ಗಮನಹರಿಸುವುದು ಅತ್ಯಗತ್ಯ. AsyncLocalStorage ನ ಅತಿಯಾದ ಬಳಕೆಯು ಓವರ್‌ಹೆಡ್ ಅನ್ನು ಪರಿಚಯಿಸಬಹುದು, ವಿಶೇಷವಾಗಿ ಹೈ-ಥ್ರೋಪುಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ. ಸಂಭಾವ್ಯ ಅಡಚಣೆಗಳನ್ನು ಗುರುತಿಸಲು ಮತ್ತು ಅದಕ್ಕೆ ತಕ್ಕಂತೆ ಆಪ್ಟಿಮೈಜ್ ಮಾಡಲು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಪ್ರೊಫೈಲ್ ಮಾಡಿ.

AsyncLocalStorage ನಲ್ಲಿ ಹೆಚ್ಚಿನ ಪ್ರಮಾಣದ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸುವುದನ್ನು ತಪ್ಪಿಸಿ. ಅಗತ್ಯವಾದ ಕಾಂಟೆಕ್ಸ್ಟ್ ವೇರಿಯಬಲ್ಸ್ ಅನ್ನು ಮಾತ್ರ ಸಂಗ್ರಹಿಸಿ. ನೀವು ದೊಡ್ಡ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸಬೇಕಾದರೆ, ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಬದಲಿಗೆ ಅವುಗಳ ರೆಫರೆನ್ಸ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸುವುದನ್ನು ಪರಿಗಣಿಸಿ.

AsyncLocalStorage ಗೆ ಪರ್ಯಾಯಗಳು

AsyncLocalStorage ಒಂದು ಪ್ರಬಲ ಸಾಧನವಾಗಿದ್ದರೂ, ನಿಮ್ಮ ನಿರ್ದಿಷ್ಟ ಅಗತ್ಯಗಳು ಮತ್ತು ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗೆ ಅನುಗುಣವಾಗಿ ಅಸಿಂಕ್ರೋನಸ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ಅನ್ನು ನಿರ್ವಹಿಸಲು ಪರ್ಯಾಯ ವಿಧಾನಗಳಿವೆ.

• ಸ್ಪಷ್ಟ ಕಾಂಟೆಕ್ಸ್ಟ್ ಪಾಸಿಂಗ್: ಮೊದಲೇ ಹೇಳಿದಂತೆ, ಕಾಂಟೆಕ್ಸ್ಟ್ ವೇರಿಯಬಲ್ಸ್ ಅನ್ನು ಫಂಕ್ಷನ್‌ಗಳಿಗೆ ಆರ್ಗ್ಯುಮೆಂಟ್ ಆಗಿ ಸ್ಪಷ್ಟವಾಗಿ ಪಾಸ್ ಮಾಡುವುದು ಒಂದು ಮೂಲಭೂತ, ಆದರೆ ಕಡಿಮೆ ಸುಂದರವಾದ ವಿಧಾನವಾಗಿದೆ.
• ಕಾಂಟೆಕ್ಸ್ಟ್ ಆಬ್ಜೆಕ್ಟ್ಸ್: ಮೀಸಲಾದ ಕಾಂಟೆಕ್ಸ್ಟ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ರಚಿಸಿ ಅದನ್ನು ಪಾಸ್ ಮಾಡುವುದರಿಂದ ವೈಯಕ್ತಿಕ ವೇರಿಯಬಲ್ಸ್ ಅನ್ನು ಪಾಸ್ ಮಾಡುವುದಕ್ಕಿಂತ ಓದುವಿಕೆಯನ್ನು ಸುಧಾರಿಸಬಹುದು.
• ಫ್ರೇಮ್‌ವರ್ಕ್-ನಿರ್ದಿಷ್ಟ ಪರಿಹಾರಗಳು: ಅನೇಕ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳು ತಮ್ಮದೇ ಆದ ಕಾಂಟೆಕ್ಸ್ಟ್ ನಿರ್ವಹಣಾ ಯಾಂತ್ರಿಕ ವ್ಯವಸ್ಥೆಗಳನ್ನು ಒದಗಿಸುತ್ತವೆ. ಉದಾಹರಣೆಗೆ, NestJS ರಿಕ್ವೆಸ್ಟ್-ಸ್ಕೋಪ್ಡ್ ಪ್ರೊವೈಡರ್‌ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.

ಜಾಗತಿಕ ದೃಷ್ಟಿಕೋನ ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

ಜಾಗತಿಕ ಕಾಂಟೆಕ್ಸ್ಟ್‌ನಲ್ಲಿ ಅಸಿಂಕ್ರೋನಸ್ ಕಾಂಟೆಕ್ಸ್ಟ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಪರಿಗಣಿಸಿ:

• ಸಮಯ ವಲಯಗಳು: ಕಾಂಟೆಕ್ಸ್ಟ್‌ನಲ್ಲಿ ದಿನಾಂಕ ಮತ್ತು ಸಮಯದ ಮಾಹಿತಿಯೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ಸಮಯ ವಲಯಗಳ ಬಗ್ಗೆ ಗಮನವಿರಲಿ. ಅಸ್ಪಷ್ಟತೆಯನ್ನು ತಪ್ಪಿಸಲು ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳೊಂದಿಗೆ ಸಮಯ ವಲಯದ ಮಾಹಿತಿಯನ್ನು ಸಂಗ್ರಹಿಸಿ.
• ಸ್ಥಳೀಕರಣ: ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಬಹು ಭಾಷೆಗಳನ್ನು ಬೆಂಬಲಿಸಿದರೆ, ವಿಷಯವನ್ನು ಸರಿಯಾದ ಭಾಷೆಯಲ್ಲಿ ಪ್ರದರ್ಶಿಸಲಾಗಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಬಳಕೆದಾರರ ಲೊಕೇಲ್ ಅನ್ನು ಕಾಂಟೆಕ್ಸ್ಟ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಿ.
• ಕರೆನ್ಸಿ: ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಹಣಕಾಸು ವಹಿವಾಟುಗಳನ್ನು ನಿರ್ವಹಿಸಿದರೆ, ಮೊತ್ತವನ್ನು ಸರಿಯಾಗಿ ಪ್ರದರ್ಶಿಸಲಾಗಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಬಳಕೆದಾರರ ಕರೆನ್ಸಿಯನ್ನು ಕಾಂಟೆಕ್ಸ್ಟ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಿ.
• ಡೇಟಾ ಫಾರ್ಮ್ಯಾಟ್‌ಗಳು: ವಿವಿಧ ಪ್ರದೇಶಗಳಲ್ಲಿ ಬಳಸುವ ವಿಭಿನ್ನ ಡೇಟಾ ಫಾರ್ಮ್ಯಾಟ್‌ಗಳ ಬಗ್ಗೆ ತಿಳಿದಿರಲಿ. ಉದಾಹರಣೆಗೆ, ದಿನಾಂಕ ಫಾರ್ಮ್ಯಾಟ್‌ಗಳು ಮತ್ತು ಸಂಖ್ಯೆ ಫಾರ್ಮ್ಯಾಟ್‌ಗಳು ಗಮನಾರ್ಹವಾಗಿ ಬದಲಾಗಬಹುದು.

ತೀರ್ಮಾನ

AsyncLocalStorage ಅಸಿಂಕ್ರೋನಸ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪರಿಸರದಲ್ಲಿ ರಿಕ್ವೆಸ್ಟ್-ಸ್ಕೋಪ್ಡ್ ವೇರಿಯಬಲ್ಸ್ ಅನ್ನು ನಿರ್ವಹಿಸಲು ಪ್ರಬಲ ಮತ್ತು ಸುಂದರವಾದ ಪರಿಹಾರವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಅಸಿಂಕ್ರೋನಸ್ ಗಡಿಗಳಾದ್ಯಂತ ನಿರಂತರ ಕಾಂಟೆಕ್ಸ್ಟ್ ಅನ್ನು ರಚಿಸುವ ಮೂಲಕ, ಇದು ಕೋಡ್ ಅನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ, ಜೋಡಣೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ, ಮತ್ತು ನಿರ್ವಹಣೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ. ಅದರ ಸಾಮರ್ಥ್ಯಗಳು ಮತ್ತು ಮಿತಿಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ನೀವು ದೃಢವಾದ, ಸ್ಕೇಲೆಬಲ್, ಮತ್ತು ಜಾಗತಿಕವಾಗಿ-ಅರಿವುಳ್ಳ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು AsyncLocalStorage ಅನ್ನು ಬಳಸಿಕೊಳ್ಳಬಹುದು.

ಅಸಿಂಕ್ರೋನಸ್ ಕೋಡ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಯಾವುದೇ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಡೆವಲಪರ್‌ಗೆ ಅಸಿಂಕ್ರೋನಸ್ ಕಾಂಟೆಕ್ಸ್ಟ್‌ನಲ್ಲಿ ಪ್ರಾವೀಣ್ಯತೆ ಸಾಧಿಸುವುದು ಅತ್ಯಗತ್ಯ. ಸ್ವಚ್ಛ, ಹೆಚ್ಚು ನಿರ್ವಹಿಸಬಲ್ಲ, ಮತ್ತು ಹೆಚ್ಚು ವಿಶ್ವಾಸಾರ್ಹ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಬರೆಯಲು AsyncLocalStorage ಮತ್ತು ಇತರ ಕಾಂಟೆಕ್ಸ್ಟ್ ನಿರ್ವಹಣಾ ತಂತ್ರಗಳನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳಿ.